<?php
/**
 * XmuSlh, web platform of Student Association Federation of Xiamen University
 * 
 * Rewritting one or some pages of StatusNet. 
 * To get the original version, please visit <http://status.net/>.
 * 
 * StatusNet, the distributed open-source microblogging tool
 * 
 * LICENCE: This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * A wrapper on uploaded files.
 * 
 * Makes it slightly easier to accept an image file from upload.
 * 
 * 一个用用于接收图片上传的包装类.
 * 
 * @author		ytukie <ytukie@gmail.com>
 * @version		0.21
 * 
 * 0.2)  Some adjustments.
 * 0.21) Replace 'if ($transparent_idx >= 0) {' in line 259 to
 * 				 'if ($transparent_idx >= 0 && $transparent_idx < 255) {'
 * 		 To fix the out of range warning.
 * 0.22) Adds the 'pictureResize' function? Just copied from 'photoResize'?
 * 0.23) Adds the variable 'size', and 'name'. 	
 * 0.24) Adds the corresponding 'poster' handler functions.			 
 */

// XmuSlh only.
if ( !defined('XMUSLH')) { exit(1); }

// Requirements.
require_once INSTALLDIR . '/lib/slh_util.php';
require_once INSTALLDIR . '/classes/Avatar.php';
require_once INSTALLDIR . '/classes/Photo.php';

class ImageFile
{
	var $id;
	var $filepath;
	var $mimetype;		// image/xxx
	var $width;
	var $height;
	var $size;
	var $name;
	
	function __construct($id,
						 $filepath, 
						 $name = null, 
						 $size = null, 
						 $mimetype = null, 
						 $width = null, 
						 $height = null
						 )
	{
		$this->id = $id;
		$this->filepath = $filepath;
		$this->name = $name;
		$this->size = $size;
			
		$info = @getimagesize($this->filepath);
		
		if ( !(
	            ($info[2] == IMAGETYPE_GIF && function_exists('imagecreatefromgif')) ||
	            ($info[2] == IMAGETYPE_JPEG && function_exists('imagecreatefromjpeg')) ||
	            $info[2] == IMAGETYPE_BMP ||
	            ($info[2] == IMAGETYPE_WBMP && function_exists('imagecreatefromwbmp')) ||
	            ($info[2] == IMAGETYPE_XBM && function_exists('imagecreatefromxbm')) ||
	            ($info[2] == IMAGETYPE_PNG && function_exists('imagecreatefrompng')))
	       ) {
	       	@unlink($filepath);
            // TRANS: Exception thrown when trying to upload an unsupported image file format.
            throw new Exception(_('Unsupported image file format.'));
            return;
        }
        
        $this->mimetype = ($info) ? $info[2] : $mimetype;
        $this->width = ($info) ? $info[0] : $width;
        $this->height = ($info) ? $info[1] : $height;
	}
	
	/**
	 * The upload method!
	 * Differs from the original method?
	 */
	static function fromUpload($param = 'upload')
	{
		if ( !isset($_FILES[$param])) {
			return;
		}
		
		switch ($_FILES[$param]['error']) {
			case UPLOAD_ERR_OK: // success, jump out.
				break;
			case UPLOAD_ERR_INI_SIZE:
			case UPLOAD_ERR_FORM_SIZE:
				throw new Exception('That file size is over the limit.');
				return;
			case UPLOAD_ERR_PARTIAL:
				@unlink($_FILES[$param]['tmp_name']);
				throw new Exception('Partial upload.');
				return;
			case UPLOAD_ERR_NO_FILE:
				// No file, probably just a non-AJAX submission.
				return;
			default:
				// FIXME: To log?
				slh_log(LOG_ERR, __METHOD__ . ": Unkwon upload error " .
					$_FILES[$param]['error']);
				throw new Exception('System error uploading file.');
				return;
		}
		
		$info = @getimagesize($_FILES[$param]['tmp_name']);
		
		if ( !$info) {
			@unlink($_FILES[$param]['tmp_name']);
			throw new Exception('Not an image or corrupt file.');
			return;
		}
		
		
		return new ImageFile('0', 
							 $_FILES[$param]['tmp_name'], 
							 $_FILES[$param]['name'], 
							 $_FILES[$param]['size']);
	}
	
	/**
	 * Compat interface for old code generating avatar thumbnails...
	 * Saves the scaled file directly into the avatar area.
	 */
	function avatarResize($width,
						  $height, 
						  $x = 0, 
						  $y = 0, 
						  $w = null, 
						  $h = null)
	{
		// Get the target type.
		$targetType = $this->preferredType();
		$outname = Avatar::filename($this->id,
									image_type_to_extension($targetType),
									($width > $height) ? $width : $height,
									uniqid());
		$outpath = Avatar::path($outname);
		$this->resizeTo($outpath, $width, $height, $x, $y, $w, $h);
		return $outname;
	}
	
	/**
	 * Compat interface for old code generating photo! thumbnails...
	 * Saves the scaled file directly into the photo's area.
	 * 
	 * @param $width, the given max width of the thumbnail.
	 * @param $height, the given max height of the thumbnail.
	 */
	function photoResize($outpath,
						 $width,
						 $height)
	{
		// To Fit the given width and height without scaling.
		// Change the width and height.
		if ($this->width <= $width &&
			$this->height <= $height) {
			return $this->resizeTo($outpath, $this->width, $this->height);
		}
		
		$oriRate = $this->width / $this->height;
		$thuRate = $width / $height;
		
		if ($oriRate > $thuRate) {
			/*
			$newWidth = $width;
			$newHeight = $newWidth / $oriRate;
			*/
			return $this->resizeTo($outpath, $width, ($width / $oriRate));
		} else {
			/*
			$newHeight = $height;
			$newWidth = $newHeight * $oriRate;
			*/
			return $this->resizeTo($outpath, ($height * $oriRate), $height);
		}
	}
	
	/**
	 * Compat interface for old code generating picture! thumbnails...
	 * Saves the scaled file directly into the photo's area.
	 * 
	 * @param $width, the given max width of the thumbnail.
	 * @param $height, the given max height of the thumbnail.
	 */
	function pictureResize($outpath,
						   $width,
						   $height)
	{
		// To Fit the given width and height without scaling.
		// Change the width and height.
		if ($this->width <= $width &&
			$this->height <= $height) {
			return $this->resizeTo($outpath, $this->width, $this->height);
		}
		
		$oriRate = $this->width / $this->height;
		$thuRate = $width / $height;
		
		if ($oriRate > $thuRate) {
			/*
			$newWidth = $width;
			$newHeight = $newWidth / $oriRate;
			*/
			return $this->resizeTo($outpath, $width, ($width / $oriRate));
		} else {
			/*
			$newHeight = $height;
			$newWidth = $newHeight * $oriRate;
			*/
			return $this->resizeTo($outpath, ($height * $oriRate), $height);
		}
	}
	
	/**
	 * Compat interface for old code generating picture! thumbnails...
	 * Saves the scaled file directly into the photo's area.
	 * 
	 * The scale of the poster might be constant.
	 * 
	 * @param $width, the given max width of the thumbnail.
	 * @param $height, the given max height of the thumbnail.
	 */
	function posterResize($outpath, 
						  $width, 
						  $height, 
						  $x = 0, 
						  $y = 0, 
						  $w = null, 
						  $h = null)
	{
		// Just the width and the height
		return $this->resizeTo($outpath, $width, $height, $x, $y, $w, $h);
	}
	
	/**
	 * Copy the image file to the given destination.
	 * For obscure formats, this will automatically convert to PNG;
	 * otherwise the original file will be copies as-is.
	 */
	function copyTo($outpath)
	{
		return $this->resizeTo($outpath, $this->width, $this->height);
	}
	
	/**
	 * Create and save a thumbnail image.
	 */
	function resizeTo($outpath, 
					  $width, 
					  $height, 
					  $x = 0, 
					  $y = 0, 
					  $w = null, 
					  $h = null)
	{
		$w = ($w === null) ? $this->width : $w;
		$h = ($h === null) ? $this->height: $h;
		$targetType = $this->preferredType();
		
		if ( !file_exists($this->filepath)) {
			throw new Exception('Lost our file');
			return;
		}
		
		// Don't crop/scale if it isn't necessary
		if ($width === $this->width &&
			$height === $this->height &&
			$x === 0 &&
			$y === 0 &&
			$w === $this->width &&
			$h === $this->height &&
			$targetType === $this->mimetype) {
			
			@copy($this->filepath, $outpath);
			return $outpath;
		}
		
		switch ($this->mimetype) {
        	case IMAGETYPE_GIF:
	            $image_src = imagecreatefromgif($this->filepath);
	            break;
        	case IMAGETYPE_JPEG:
	            $image_src = imagecreatefromjpeg($this->filepath);
	            break;
        	case IMAGETYPE_PNG:
	            $image_src = imagecreatefrompng($this->filepath);
	            break;
        	case IMAGETYPE_BMP:
	            $image_src = imagecreatefrombmp($this->filepath);
	            break;
        	case IMAGETYPE_WBMP:
	            $image_src = imagecreatefromwbmp($this->filepath);
	            break;
	        case IMAGETYPE_XBM:
	            $image_src = imagecreatefromxbm($this->filepath);
	            break;
        	default:
	            // TRANS: Exception thrown when trying to resize an unknown file type.
	            throw new Exception(_('Unknown file type'));
	            return;
        }
        
        $image_dest = imagecreatetruecolor($width, $height);
        
        if ($this->mimetype === IMAGETYPE_GIF || 
        	$this->mimetype === IMAGETYPE_PNG ||
        	$this->mimetype === IMAGETYPE_BMP) {
        	$transparent_idx = imagecolortransparent($image_src);

        	if ($transparent_idx >= 0 && $transparent_idx < 255) {

                $transparent_color = imagecolorsforindex($image_src, $transparent_idx);
                $transparent_idx = imagecolorallocate($image_dest, $transparent_color['red'], $transparent_color['green'], $transparent_color['blue']);
                imagefill($image_dest, 0, 0, $transparent_idx);
                imagecolortransparent($image_dest, $transparent_idx);

            } elseif ($this->mimetype == IMAGETYPE_PNG) {

                imagealphablending($image_dest, false);
                $transparent = imagecolorallocatealpha($image_dest, 0, 0, 0, 127);
                imagefill($image_dest, 0, 0, $transparent);
                imagesavealpha($image_dest, true);

            }
        }
        
        imagecopyresampled($image_dest, $image_src, 0, 0, $x, $y, $width, $height, $w, $h);
        
		switch ($targetType) {
	        case IMAGETYPE_GIF:
	            imagegif($image_dest, $outpath);
	            break;
	        case IMAGETYPE_JPEG:
	            imagejpeg($image_dest, $outpath, 100);
	            break;
	        case IMAGETYPE_PNG:
	            imagepng($image_dest, $outpath);
	            break;
	        default:
	            // TRANS: Exception thrown when trying resize an unknown file type.
	            throw new Exception(_('Unknown file type'));
	            return;
        }
        
        imagedestroy($image_src);
        imagedestroy($image_dest);
        
        return $outpath;
	}
	
	/**
	 * Sereral obscure file types should be normalized to PNG on resize.
	 */
	function preferredType()
	{
		if($this->mimetype == IMAGETYPE_BMP) {
            //we don't want to save BMP... it's an inefficient, rare, antiquated format
            //save png instead
            return IMAGETYPE_PNG;
        } else if($this->mimetype == IMAGETYPE_WBMP) {
            //we don't want to save WBMP... it's a rare format that we can't guarantee clients will support
            //save png instead
            return IMAGETYPE_PNG;
        } else if($this->mimetype == IMAGETYPE_XBM) {
            //we don't want to save XBM... it's a rare format that we can't guarantee clients will support
            //save png instead
            return IMAGETYPE_PNG;
        }
        return $this->mimetype;
	}
	
	/**
	 * Deleting.
	 */
	function unlink()
	{
		@unlink($this->filepath);
	}
// FIXME: The FILE?	Too complecated?
	static function maxAvatarSize()
	{
		return ImageFile::convertSize(ImageFile::maxAvatarSizeInt());
	}
	
	static function maxAvatarSizeInt()
	{
		return min(ImageFile::strToInt(ini_get('post_max_size')),
				   ImageFile::strToInt(ini_get('upload_max_filesize')),
				   ImageFile::strToInt(ini_get('memory_limit')),
				   ImageFile::strToInt(slh_config('avatar', 'maxavatarsize')));
	}
	
	static function maxPhotoSize()
	{
		return ImageFile::convertSize(ImageFile::maxPhotoSizeInt());
	}
	
	static function maxPhotoSizeInt()
	{
		return min(ImageFile::strToInt(ini_get('post_max_size')),
				   ImageFile::strToInt(ini_get('upload_max_filesize')),
				   ImageFile::strToInt(ini_get('memory_limit')),
				   ImageFile::strToInt(slh_config('photo', 'maxphotosize')));
	}
	
	static function maxPictureSize()
	{
		return ImageFile::convertSize(ImageFile::maxPictureSizeInt());
	}
	
	static function maxPictureSizeInt()
	{
		return min(ImageFile::strToInt(ini_get('post_max_size')),
				   ImageFile::strToInt(ini_get('upload_max_filesize')),
				   ImageFile::strToInt(ini_get('memory_limit')),
				   ImageFile::strToInt(slh_config('picture', 'maxpicturesize')));
	}
	
	static function maxPosterSize()
	{
		return ImageFile::convertSize(ImageFile::maxPosterSizeInt());
	}
	
	static function maxPosterSizeInt()
	{
		return min(ImageFile::strToInt(ini_get('post_max_size')),
				   ImageFile::strToInt(ini_get('upload_max_filesize')),
				   ImageFile::strToInt(ini_get('memory_limit')),
				   ImageFile::strToInt(slh_config('poster', 'maxpostersize')));
	}

	static function convertSize($value)
	{
		if ($value >= 1024 * 1024) {
			$value = $value / (1024 * 1024);
			return $value . 'MB';
		} else if ($value >= 1024) {
			return $value . 'KB';
		} else {
			return $value . 'DB';
		}
	}
	
	static function strToInt($str)
	{
		$uint = substr($str, -1);
		$num = substr($str, 0, -1);
		
		switch(strtoupper($uint)) {
			case 'G':
				$num *= 1024;
			case 'M':
				$num *= 1024;
			case 'K':
				$num *= 1024;
		}
		
		return $num;
	}
}

//PHP doesn't (as of 2/24/2010) have an imagecreatefrombmp so conditionally define one
if(!function_exists('imagecreatefrombmp')) {
    //taken shamelessly from http://www.php.net/manual/en/function.imagecreatefromwbmp.php#86214
    function imagecreatefrombmp($p_sFile)
    {
        // Load the image into a string
        $file    =    fopen($p_sFile,"rb");
        $read    =    fread($file,10);
        while(!feof($file)&&($read<>""))
            $read    .=    fread($file,1024);

        $temp    =    unpack("H*",$read);
        $hex    =    $temp[1];
        $header    =    substr($hex,0,108);

        //    Process the header
        //    Structure: http://www.fastgraph.com/help/bmp_header_format.html
        if (substr($header,0,4)=="424d")
        {
            //    Cut it in parts of 2 bytes
            $header_parts    =    str_split($header,2);

            //    Get the width        4 bytes
            $width            =    hexdec($header_parts[19].$header_parts[18]);

            //    Get the height        4 bytes
            $height            =    hexdec($header_parts[23].$header_parts[22]);

            //    Unset the header params
            unset($header_parts);
        }

        //    Define starting X and Y
        $x                =    0;
        $y                =    1;

        //    Create newimage
        $image            =    imagecreatetruecolor($width,$height);

        //    Grab the body from the image
        $body            =    substr($hex,108);

        //    Calculate if padding at the end-line is needed
        //    Divided by two to keep overview.
        //    1 byte = 2 HEX-chars
        $body_size        =    (strlen($body)/2);
        $header_size    =    ($width*$height);

        //    Use end-line padding? Only when needed
        $usePadding        =    ($body_size>($header_size*3)+4);

        //    Using a for-loop with index-calculation instaid of str_split to avoid large memory consumption
        //    Calculate the next DWORD-position in the body
        for ($i=0;$i<$body_size;$i+=3)
        {
            //    Calculate line-ending and padding
            if ($x>=$width)
            {
                //    If padding needed, ignore image-padding
                //    Shift i to the ending of the current 32-bit-block
                if ($usePadding)
                    $i    +=    $width%4;

                //    Reset horizontal position
                $x    =    0;

                //    Raise the height-position (bottom-up)
                $y++;

                //    Reached the image-height? Break the for-loop
                if ($y>$height)
                    break;
            }

            //    Calculation of the RGB-pixel (defined as BGR in image-data)
            //    Define $i_pos as absolute position in the body
            $i_pos    =    $i*2;
            $r        =    hexdec($body[$i_pos+4].$body[$i_pos+5]);
            $g        =    hexdec($body[$i_pos+2].$body[$i_pos+3]);
            $b        =    hexdec($body[$i_pos].$body[$i_pos+1]);

            //    Calculate and draw the pixel
            $color    =    imagecolorallocate($image,$r,$g,$b);
            imagesetpixel($image,$x,$height-$y,$color);

            //    Raise the horizontal position
            $x++;
        }

        //    Unset the body / free the memory
        unset($body);

        //    Return image-object
        return $image;
    }
}

?>